package com.njworkorder.Utils;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;

/**
 * JSON文件解析工具类
 * 支持将JSON文件内容解析为指定类型的对象或对象列表
 */
public class JsonFileParser {

    private static final Logger logger = LoggerFactory.getLogger(JsonFileParser.class);
    private static final ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 私有构造函数，防止实例化
     */
    private JsonFileParser() {
        throw new IllegalStateException("工具类不应被实例化");
    }

    /**
     * 从文件路径读取JSON并转换为指定类型的对象列表
     *
     * @param filePath 文件路径
     * @param clazz 目标类型的Class对象
     * @param <T> 目标类型
     * @return 指定类型的对象列表
     */
    public static <T> List<T> parseJsonFileToList(String filePath, Class<T> clazz) {
        try {
            String jsonContent = new String(Files.readAllBytes(Paths.get(filePath)));
            return objectMapper.readValue(
                    jsonContent,
                    objectMapper.getTypeFactory().constructCollectionType(List.class, clazz)
            );
        } catch (IOException e) {
            logger.error("解析JSON文件失败: {}", e.getMessage(), e);
            return Collections.emptyList();
        }
    }

    /**
     * 从文件对象读取JSON并转换为指定类型的对象列表
     *
     * @param file 文件对象
     * @param clazz 目标类型的Class对象
     * @param <T> 目标类型
     * @return 指定类型的对象列表
     */
    public static <T> List<T> parseJsonFileToList(File file, Class<T> clazz) {
        try {
            return objectMapper.readValue(
                    file,
                    objectMapper.getTypeFactory().constructCollectionType(List.class, clazz)
            );
        } catch (IOException e) {
            logger.error("解析JSON文件失败: {}", e.getMessage(), e);
            return Collections.emptyList();
        }
    }

    /**
     * 从文件路径读取JSON并转换为指定类型的对象
     *
     * @param filePath 文件路径
     * @param clazz 目标类型的Class对象
     * @param <T> 目标类型
     * @return 指定类型的对象
     */
    public static <T> T parseJsonFileToObject(String filePath, Class<T> clazz) {
        try {
            String jsonContent = new String(Files.readAllBytes(Paths.get(filePath)));
            return objectMapper.readValue(jsonContent, clazz);
        } catch (IOException e) {
            logger.error("解析JSON文件失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 从文件对象读取JSON并转换为指定类型的对象
     *
     * @param file 文件对象
     * @param clazz 目标类型的Class对象
     * @param <T> 目标类型
     * @return 指定类型的对象
     */
    public static <T> T parseJsonFileToObject(File file, Class<T> clazz) {
        try {
            return objectMapper.readValue(file, clazz);
        } catch (IOException e) {
            logger.error("解析JSON文件失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 从文件路径读取JSON并转换为复杂类型的对象
     * 适用于泛型嵌套的复杂类型，如List<Map<String, Object>>
     *
     * @param filePath 文件路径
     * @param typeReference 类型引用
     * @param <T> 目标类型
     * @return 指定类型的对象
     */
    public static <T> T parseJsonFileToType(String filePath, TypeReference<T> typeReference) {
        try {
            String jsonContent = new String(Files.readAllBytes(Paths.get(filePath)));
            return objectMapper.readValue(jsonContent, typeReference);
        } catch (IOException e) {
            logger.error("解析JSON文件失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 从文件对象读取JSON并转换为复杂类型的对象
     * 适用于泛型嵌套的复杂类型，如List<Map<String, Object>>
     *
     * @param file 文件对象
     * @param typeReference 类型引用
     * @param <T> 目标类型
     * @return 指定类型的对象
     */
    public static <T> T parseJsonFileToType(File file, TypeReference<T> typeReference) {
        try {
            return objectMapper.readValue(file, typeReference);
        } catch (IOException e) {
            logger.error("解析JSON文件失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 将对象转换为JSON字符串
     *
     * @param object 要转换的对象
     * @return JSON字符串
     */
    public static String toJsonString(Object object) {
        try {
            return objectMapper.writeValueAsString(object);
        } catch (IOException e) {
            logger.error("对象转JSON字符串失败: {}", e.getMessage(), e);
            return "{}";
        }
    }

    /**
     * 将JSON字符串转换为指定类型的对象
     *
     * @param jsonString JSON字符串
     * @param clazz 目标类型的Class对象
     * @param <T> 目标类型
     * @return 指定类型的对象
     */
    public static <T> T parseJsonString(String jsonString, Class<T> clazz) {
        try {
            return objectMapper.readValue(jsonString, clazz);
        } catch (IOException e) {
            logger.error("JSON字符串转对象失败: {}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 将JSON字符串转换为指定类型的对象列表
     *
     * @param jsonString JSON字符串
     * @param clazz 目标类型的Class对象
     * @param <T> 目标类型
     * @return 指定类型的对象列表
     */
    public static <T> List<T> parseJsonStringToList(String jsonString, Class<T> clazz) {
        try {
            return objectMapper.readValue(
                    jsonString,
                    objectMapper.getTypeFactory().constructCollectionType(List.class, clazz)
            );
        } catch (IOException e) {
            logger.error("JSON字符串转对象列表失败: {}", e.getMessage(), e);
            return Collections.emptyList();
        }
    }
}
